import baseConfig from './config.js';

const host = baseConfig.host;

// 获取token的辅助函数
const getToken = () => {
	try {
		const userInfo = uni.getStorageSync('userInfo');
		return userInfo && userInfo.token ? userInfo.token : null;
	} catch (e) {
		return null;
	}
};

// 统一的响应处理函数
const handleResponse = (res, resolve, reject) => {
	// HTTP状态码检查
	if (res.statusCode !== 200) {
		uni.showToast({
			title: '网络开小差了，请稍后再试',
			icon: 'none',
			duration: 2000
		});
		reject(new Error(`HTTP ${res.statusCode}`));
		return;
	}

	const { code, msg, data } = res.data;

	// 业务状态码处理
	switch (code) {
		case 0:
			// 成功
			resolve(res.data);
			break;
		case 10004:
		case 100041:
			// 登录过期
			uni.showToast({
				icon: 'none',
				duration: 2000,
				title: '登录过期，请重新登录',
				success() {
					// 清除用户登录数据
					uni.removeStorage({
						key: 'userInfo'
					});
					setTimeout(() => {
						uni.reLaunch({
							url: '/pages/login/login'
						});
					}, 2000);
				}
			});
			reject(new Error(msg || '登录过期'));
			break;
		default:
			// 其他业务错误
			uni.showToast({
				title: msg || '请求失败',
				icon: 'none'
			});
			reject(new Error(msg || '请求失败'));
			break;
	}
};

const request = {
	// POST请求
	post: function post(url, parm = {}, needToken = true) {
		return new Promise((resolve, reject) => {
			let headers = {};
			let requestData = parm;
			
			// 对于登录接口，如果后端需要FormData格式，我们需要特殊处理
			if (url.includes('/login')) {
				// 在uni-app中，我们可以直接传递对象，uni.request会自动处理
				// 但如果后端严格要求FormData格式，我们设置正确的content-type
				headers['content-type'] = 'application/x-www-form-urlencoded';
				requestData = parm;
			} else {
				// 普通POST请求
				headers['content-type'] = 'application/x-www-form-urlencoded';
			}

			// 如果需要token且存在token，则添加到请求头
			if (needToken) {
				const token = getToken();
				if (token) {
					headers['token'] = `${token}`;
					// 或者根据后端要求，可能是：
					// headers['token'] = token;
					// 或者添加到请求参数中：
					// requestData.token = token;
				}
			}

			console.log('请求信息:', {
				url: host + url,
				method: 'POST',
				data: requestData,
				header: headers
			});

			uni.request({
				url: host + url,
				method: 'POST',
				data: requestData,
				header: headers,
				success: (res) => {
					console.log('请求成功:', res);
					handleResponse(res, resolve, reject);
				},
				fail: (error) => {
					console.error('请求失败:', error);
					uni.showToast({
						title: '网络开小差了，请稍后再试',
						icon: 'none',
						duration: 2000
					});
					reject(error);
				}
			});
		});
	},
	
	// GET请求
	get: function get(url, parm = {}, needToken = true) {
		return new Promise((resolve, reject) => {
			const headers = {
				'content-type': 'application/x-www-form-urlencoded'
			};

			// 如果需要token且存在token，则添加到请求头
			if (needToken) {
				const token = getToken();
				if (token) {
					headers['token'] = `${token}`;
					// 或者根据后端要求，可能是：
					// headers['token'] = token;
					// 或者添加到请求参数中：
					// parm.token = token;
				}
			}

			uni.request({
				url: host + url,
				method: 'GET',
				data: parm,
				header: headers,
				success: (res) => {
					handleResponse(res, resolve, reject);
				},
				fail: (error) => {
					uni.showToast({
						title: '网络开小差了，请稍后再试',
						icon: 'none',
						duration: 2000
					});
					reject(error);
				}
			});
		});
	},

	// PUT请求
	put: function put(url, parm = {}, needToken = true) {
		return new Promise((resolve, reject) => {
			const headers = {
				'content-type': 'application/json'
			};

			if (needToken) {
				const token = getToken();
				if (token) {
					headers['token'] = `${token}`;
				}
			}

			uni.request({
				url: host + url,
				method: 'PUT',
				data: parm,
				header: headers,
				success: (res) => {
					handleResponse(res, resolve, reject);
				},
				fail: (error) => {
					uni.showToast({
						title: '网络开小差了，请稍后再试',
						icon: 'none',
						duration: 2000
					});
					reject(error);
				}
			});
		});
	},

	// DELETE请求
	delete: function del(url, parm = {}, needToken = true) {
		return new Promise((resolve, reject) => {
			const headers = {
				'content-type': 'application/json'
			};

			if (needToken) {
				const token = getToken();
				if (token) {
					headers['token'] = `${token}`;
				}
			}

			uni.request({
				url: host + url,
				method: 'DELETE',
				data: parm,
				header: headers,
				success: (res) => {
					handleResponse(res, resolve, reject);
				},
				fail: (error) => {
					uni.showToast({
						title: '网络开小差了，请稍后再试',
						icon: 'none',
						duration: 2000
					});
					reject(error);
				}
			});
		});
	},

	// 文件上传 - 支持FormData格式
	upload: function upload(url, filePath, fieldName = 'file', extraFormData = {}, needToken = true) {
		return new Promise((resolve, reject) => {
			// 构建完整的URL
			const fullUrl = host + url;
			
			// 设置请求头 - 不要手动设置content-type，让uni.uploadFile自动处理
			const header = {};
			
			// 添加token
			if (needToken) {
				const token = getToken();
				if (token) {
					header.token = token;
				}
			}
			
			// 构建FormData - 将额外的表单数据合并
			const formData = { ...extraFormData };
			
			console.log('文件上传请求信息:', {
				url: fullUrl,
				filePath,
				name: fieldName,
				formData,
				header
			});
			
			uni.uploadFile({
				url: fullUrl,
				filePath: filePath,
				name: fieldName, // 文件字段名
				formData: formData, // 额外的表单数据
				header: header,
				success: (res) => {
					console.log('文件上传响应:', res);
					
					// uni.uploadFile返回的是字符串，需要解析
					let responseData;
					try {
						responseData = typeof res.data === 'string' ? JSON.parse(res.data) : res.data;
					} catch (e) {
						console.error('解析上传响应失败:', e, '原始响应:', res.data);
						reject(new Error('响应格式错误'));
						return;
					}
					
					// 构造标准响应格式
					const standardResponse = {
						statusCode: res.statusCode,
						data: responseData
					};
					
					handleResponse(standardResponse, resolve, reject);
				},
				fail: (error) => {
					console.error('文件上传失败:', error);
					uni.showToast({
						title: '上传失败，请重试',
						icon: 'none',
						duration: 2000
					});
					reject(error);
				}
			});
		});
	},

	// FormData上传 - 完全支持FormData格式（如果需要更复杂的FormData处理）
	uploadFormData: function uploadFormData(url, formDataObj, needToken = true) {
		return new Promise((resolve, reject) => {
			// 如果传入的是标准的FormData对象，我们需要转换为uni-app支持的格式
			if (formDataObj instanceof FormData) {
				// 注意：uni-app的uploadFile不直接支持FormData对象
				// 需要使用request.post方法，但这种情况下文件需要特殊处理
				reject(new Error('uni-app不支持直接使用FormData对象，请使用upload方法'));
				return;
			}
			
			// 如果是普通对象，转换为uni-app的formData格式
			const { filePath, fileName, fieldName, ...otherData } = formDataObj;
			
			if (!filePath) {
				reject(new Error('filePath是必需的'));
				return;
			}
			
			this.upload(url, filePath, fieldName || 'file', otherData, needToken)
				.then(resolve)
				.catch(reject);
		});
	}

}

export default request